home *** CD-ROM | disk | FTP | other *** search
/ Network CD 2 / Network CD - Volume 2.iso / programs / internet / tcp / clients / napsaterm3.8b.lha / src.lha / src / amigadisplay.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-14  |  20.3 KB  |  886 lines
  1. RCS_ID_C="$Id: amigadisplay.c,v 3.2 1994/01/08 08:51:57 ppessi Exp $";
  2. /*
  3.  * amigadisplay.c --- Rastport drawing routines for napsaterm
  4.  *
  5.  * Author: ppessi <Pekka.Pessi@hut.fi>
  6.  *
  7.  * Copyright © 1993 Pekka Pessi
  8.  *
  9.  * Last modified: Sat Jan  8 07:42:35 1994 ppessi
  10.  *
  11.  * Copyright 1989, Chris Newman.  Changes Copyright 1989, Todd Williamson.
  12.  * All Rights Reserved
  13.  * Permission is granted to copy, modify, and use this as long
  14.  * as this notice remains intact.  This is a nifty program.
  15.  *
  16.  * Parts of this program were swiped from Joe Keane's jterm, and other parts
  17.  * were swiped from ITC's h19 terminal.
  18.  *
  19.  * DISCLAIMER: the author (and maintainer) of this program is not responsible
  20.  * for any damage or other problems caused by it.
  21.  *
  22.  * $Author: ppessi $ $Revision: 3.2 $ $Date: 1994/01/08 08:51:57 $
  23.  */
  24.  
  25. #include <assert.h>
  26. #include <stdio.h>
  27. #include <string.h>
  28. #include <ctype.h>
  29. #include "nifty.h"
  30. #include "amiga.h"
  31. #include "display.h"
  32. #include "dispmacros.h"
  33. #include "napsaprefs.h"
  34. #include "nio.h"
  35.  
  36. #include "wimp.h"
  37.  
  38. #include <graphics/gfxmacros.h>
  39. /* imported globals */
  40. extern int vt100_yucky_wrap_mode;   /* hack to do v100's wrap mode */
  41.  
  42. #define INVERT 0x50        /* Useful MinTerms  */
  43. #define WHITE  0x00
  44. #define BLACK  0xff
  45.  
  46. #define DEFDRMD JAM2        /* The default drawing mode */
  47.  
  48. /* Blitter call made to entire display.  Pass in the MinTerm */
  49. #define    INVERTALL(mode) \
  50.     BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(0), POSY(0),\
  51.               wm.x, wm.y, (mode))
  52.  
  53. static void wmputs(int x, int y, unsigned char *stng, int style);
  54.  
  55. struct RastPort *rp = NULL;     /* Drawing rastport */
  56. struct RastPort myrp;        /* A copy of Windows rastport */
  57.  
  58. /* current flash mode: 0 = not inverse */
  59. static int flashmode = 0;        
  60.  
  61. /* Output string with default style */
  62. static void putstring(short x, short y, const char *string, int len) 
  63. { 
  64.     if (disp.invert) 
  65.         SetDrMd(rp, DEFDRMD | INVERSVID); 
  66.  
  67.     Move(rp, STYLEFLAG(y) & DOUBLE_MASK ? POSX(x) << 1 : POSX(x), 
  68.         POSY(y) + wm.font.b); 
  69.  
  70.     if (np.national == NAT_7BIT) {
  71.     UBYTE shown[MAXWIDTH + 1];
  72.     long cnt = 0;
  73.     for (; cnt < len; )
  74.         shown[cnt++] = national_show[(UBYTE)*string++];
  75.     Text(rp, shown, len);
  76.     } else 
  77.     Text(rp, (UBYTE *)string, len);
  78.  
  79.     if (disp.invert)
  80.         SetDrMd(rp, DEFDRMD); 
  81. }
  82.  
  83. /* this macro outputs a string with styles */
  84. static void styleput(short x, short y, 
  85.              const char *string, short len, int style)
  86. { 
  87.     int    sputswflag = (STYLEFLAG(y) & DOUBLE_MASK) != 0; 
  88.  
  89.     putstring(x, y, string, len); 
  90.     if (XOR((style) & INVERSE,(style) &    FLASH && flashmode)) { 
  91.     BltBitMapRastPort(rp->BitMap, 0, 0, rp, 
  92.               POSX(x << sputswflag), POSY(y), 
  93.                       wm.font.w * len << sputswflag, 
  94.               wm.font.h, INVERT); 
  95.     }
  96. }
  97.  
  98. /* 
  99.  * Set appropriate font
  100.  */
  101. #define SETFONT(style, line) \
  102.   setfont(rp, ((style) | (STYLEFLAG(line) & DOUBLE_MASK)) & ATTRIB_MASK)
  103.  
  104. void dssetfont(register short style, register int line)
  105. {
  106.   /* Do only when mapped */
  107.   if (rp)
  108.     SETFONT(style, line);
  109. }
  110.  
  111.  
  112. static int cursormode = 0;    /* current cursor state 1=visible */
  113.  
  114. /*
  115.  * cursor display routine
  116.  */
  117. void dscursoron(void)
  118. {
  119.     if (rp) {
  120.     int wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) != 0;
  121.     if (!cursormode) {
  122.         cursormode = 1;
  123.         if (disp.visual == CUR_BLOCK) {
  124.         BltBitMapRastPort(rp->BitMap, 1, 1, rp, 
  125.                   POSX(disp.curx << wflag),
  126.                   POSY(disp.cury), 
  127.                   wm.font.w << wflag, wm.font.h, INVERT);
  128.         }
  129.         else if (disp.visual == CUR_UNDERLINE) {
  130.         BltBitMapRastPort(rp->BitMap, 1, 1, rp, 
  131.                   POSX(disp.curx << wflag),
  132.                   POSY(disp.cury) + wm.font.b + 1, 
  133.                   wm.font.w << wflag, 1, INVERT);
  134.         }
  135.     }
  136.     }
  137. }
  138.  
  139. void dscursoroff(void)
  140. {
  141.     if (rp) {
  142.     int wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) != 0;
  143.  
  144.     if (isSelection()) 
  145.         killSelection();
  146.     if (cursormode) {
  147.         cursormode = 0;
  148.         if (disp.visual == CUR_BLOCK) {
  149.         BltBitMapRastPort(rp->BitMap, 1, 1, rp, 
  150.                   POSX(disp.curx << wflag),
  151.                   POSY(disp.cury), 
  152.                   wm.font.w << wflag, 
  153.                   wm.font.h, 
  154.                   INVERT);
  155.         } else if (disp.visual == CUR_UNDERLINE) {
  156.         BltBitMapRastPort(rp->BitMap, 1, 1, rp, 
  157.                   POSX(disp.curx << wflag),
  158.                   POSY(disp.cury) + wm.font.b + 1, 
  159.                   wm.font.w << wflag, 
  160.                   1, 
  161.                   INVERT);
  162.         }
  163.     }
  164.     }
  165. }
  166.  
  167. void dscursorblink(void)
  168. {
  169.     if (rp) {
  170.     int wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) != 0;
  171.  
  172.     cursormode = !cursormode;
  173.     if (disp.visual == CUR_BLOCK) {
  174.             BltBitMapRastPort(rp->BitMap, 1, 1, rp, 
  175.                   POSX(disp.curx << wflag),
  176.                       POSY(disp.cury), 
  177.                   wm.font.w << wflag, 
  178.                   wm.font.h, 
  179.                   INVERT);
  180.         }
  181.     else if (disp.visual == CUR_UNDERLINE) {
  182.             BltBitMapRastPort(rp->BitMap, 1, 1, rp,
  183.                   POSX(disp.curx << wflag),
  184.                       POSY(disp.cury) + wm.font.b + 1, 
  185.                   wm.font.w << wflag, 
  186.                   1, 
  187.                   INVERT);
  188.         }
  189.     }
  190. }
  191.  
  192. long dsflashinit(void)
  193. {
  194.     timereq->tr_time.tv_secs = 1;
  195.     timereq->tr_time.tv_micro = 0;
  196.     timereq->tr_node.io_Command = TR_ADDREQUEST;
  197.     SendIO((struct IORequest *)timereq);
  198.  
  199.     return 1 << timeport->mp_SigBit;
  200. }
  201.  
  202. void dscheckflash(void)
  203. {
  204.     register int x, y, xhome;
  205.     int linelen;
  206.  
  207.     if (CheckIO(timereq)) {
  208.     WaitIO(timereq);
  209.     dsflashinit();
  210.     }
  211.  
  212.     if (!rp) return;
  213.  
  214.     flashmode = !flashmode;
  215.  
  216.     /* flash cursor */
  217.     if (disp.blink) 
  218.     dscursorblink();
  219.  
  220.     /* flash flashing text  */
  221.     for (y = 0; y < disp.winheight; y++)
  222.     if (STYLEFLAG(y) & FLASH && (linelen = LINELEN(y))) {
  223.         int wflag = (STYLEFLAG(y) & DOUBLE_MASK) != 0;
  224.         for (xhome = -1, x = 0; x <= linelen; x++)
  225.         if (x < linelen && (STYLEPOS(x,y) & FLASH)) {
  226.             if (xhome < 0)
  227.             xhome = x;
  228.         } else if (xhome > -1) {
  229.             BltBitMapRastPort(rp->BitMap, 0, 0, rp, 
  230.                       POSX(xhome << wflag), POSY(y), 
  231.                       (x - xhome) * wm.font.w << wflag, 
  232.                       wm.font.h, INVERT);
  233.             xhome = -1;
  234.         } else
  235.             xhome = -1;
  236.     }
  237. }
  238.  
  239.  
  240. /*
  241.  * redraw one line -- used for double width
  242.  */
  243. void redraw_line(int y)
  244. {
  245.     register int    x;
  246.     register char   *temp;
  247.     int            homex, style, linelen;
  248.     char        *tempmin, tempc;
  249.     short        wflag = (STYLEFLAG(y) & DOUBLE_MASK) != 0;
  250.  
  251.     if (!rp)
  252.     return;
  253.  
  254.     SETFONT(0, y);
  255.     BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(0), POSY(y), 
  256.                       wm.font.w * disp.winwidth, wm.font.h, 
  257.               disp.invert ? BLACK : WHITE);
  258.  
  259.     if ((linelen = LINELEN(y)) >= (disp.winwidth >> wflag))
  260.     linelen = (disp.winwidth >> wflag) - 1;
  261.  
  262.     if (linelen && !STYLEFLAG(y)) {
  263.     temp = (tempmin = TEXTLINE(y)) + linelen;
  264.     tempc = *temp;
  265.     *temp = 0;
  266.     putstring(0, y, tempmin, strlen(tempmin));
  267.     *temp = tempc;
  268.     } else if (linelen && STYLEFLAG(y) > 0) {
  269.     temp = tempmin = TEXTLINE(y);
  270.     style = STYLEPOS(0, y);
  271.     for (homex = x = 0; x <= linelen; x++) {
  272.         if (x < linelen && STYLEPOS(x, y) == style) {
  273.         temp++;
  274.         continue;
  275.         }
  276.         tempc = *temp;
  277.         *temp = 0;
  278.         if (style & ATTRIB_MASK)
  279.         SETFONT(style, y);
  280.         styleput(homex, y, tempmin, x - homex, style);
  281.         *temp = tempc;
  282.         tempmin = temp++;
  283.         if (style & ATTRIB_MASK)
  284.         SETFONT(0, y);
  285.         if (x < linelen) {
  286.         homex = x;
  287.         style = STYLEPOS(x, y);
  288.         }
  289.     }
  290.     }
  291.     SETFONT(disp.style, disp.cury);
  292. }
  293.  
  294. /*
  295.  * redraw the display
  296.  */
  297. void redraw_display(int resize)
  298. {
  299.     register int    x, y;
  300.     register char   *temp;
  301.     int            homex, style, linelen, wflag;
  302.     char        *tempmin, tempc;
  303.  
  304.     if (((resize || !rp) && !resize_display()) || !rp)
  305.     return;
  306.  
  307.     SETFONT(0, 0);
  308.     if (disp.invert) {
  309.     INVERTALL(BLACK);
  310.     } else
  311.         INVERTALL(WHITE);
  312.     cursormode = 0;
  313.     for (y = 0; y < disp.winheight; y++) {
  314.     wflag = (STYLEFLAG(y) & DOUBLE_MASK) != 0;
  315.     dssetfont(STYLEFLAG(y), y);
  316.     if ((linelen = LINELEN(y)) >= (disp.winwidth >> wflag))
  317.         linelen = (disp.winwidth >> wflag) - 1;
  318.     if (linelen && !STYLEFLAG(y)) {
  319.         temp = (tempmin = TEXTLINE(y)) + linelen;
  320.         tempc = *temp;
  321.         *temp = 0;
  322.         putstring(0, y, tempmin, strlen(tempmin));
  323.         *temp = tempc;
  324.     } else if (linelen != 0 && STYLEFLAG(y) > 0) {
  325.         temp = tempmin = TEXTLINE(y);
  326.         style = STYLEPOS(0, y);
  327.         for (homex = x = 0; x <= linelen + 1; x++) {
  328.         if (x <= linelen && STYLEPOS(x, y) == style) {
  329.             temp++;
  330.             continue;
  331.         }
  332.         tempc = *temp;
  333.         *temp = 0;
  334.         if (style & ATTRIB_MASK)
  335.             SETFONT(style, y);
  336.         styleput(homex, y, tempmin, x - homex, style);
  337.         *temp = tempc;
  338.         tempmin = temp++;
  339.         if (style & ATTRIB_MASK)
  340.             dssetfont(0, y);
  341.         if (x < linelen) {
  342.             homex = x;
  343.             style = STYLEPOS(x, y);
  344.         }
  345.         }
  346.     }
  347.     }
  348.  
  349.     if (isSelection()) {
  350.     invertSelection();
  351.     } else {
  352.     dscursoron();
  353.     }
  354.     SETFONT(disp.style, disp.cury);
  355. }
  356.  
  357. /*
  358.  * Show centered text
  359.  */
  360. void showbanner(struct RastPort *rp, char *text)
  361. {
  362.   size_t l = strlen(text);
  363.  
  364.   SetWrMsk(rp, 1);
  365.  
  366.   if (disp.invert) {
  367.     INVERTALL(BLACK);
  368.   } else {
  369.     INVERTALL(WHITE);
  370.   }
  371.  
  372.   if (wm.x < l * wm.font.w || wm.y < wm.font.h)
  373.     return;
  374.  
  375.   cursormode = 0;
  376.  
  377.   Move(rp, (POSX(wm.x) - l * wm.font.w) / 2, (POSY(wm.y) - wm.font.h) / 2);
  378.  
  379.   if (disp.invert) 
  380.     SetDrMd(rp, DEFDRMD | INVERSVID);
  381.  
  382.   Text(rp, text, l);
  383.  
  384.   if (disp.invert) 
  385.     SetDrMd(rp, DEFDRMD);
  386. }
  387.  
  388.  
  389. /*
  390.  * scrolling routines
  391.  */
  392. void dsscroll(int y, int numlines, int amount)
  393. {
  394.     if (rp) {
  395.     if (ABS(amount) < numlines) {
  396.         if(disp.invert) 
  397.         SetBPen(rp, 1);    
  398.         ScrollRaster(rp, 0, amount*wm.font.h, POSX(0), POSY(y), 
  399.              POSX(disp.winwidth),
  400.              POSY(y)+numlines*wm.font.h-1);
  401.         if(disp.invert) 
  402.         SetBPen(rp, 0);    
  403.     } else if(ABS(amount) >= numlines) 
  404.         BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(0), POSY(y), 
  405.                   wm.font.w*disp.winwidth, numlines*wm.font.h, 
  406.                   disp.invert ? BLACK : WHITE);
  407.     }
  408.  
  409.     if (ABS(amount) < (numlines)) {
  410.         register char *templ;
  411.         register short *templs;
  412.         register int i, maxy;
  413.         if (amount > 0) 
  414.             for(i = y, maxy = y + numlines - amount; i < maxy; i++) {
  415.                 templ  = disp.plines[i];
  416.         templs = disp.pstyles[i];
  417.                 disp.plines[i] = disp.plines[i + amount];
  418.         disp.pstyles[i] = disp.pstyles[i + amount];
  419.         disp.plines[i + amount] = templ;
  420.         disp.pstyles[i + amount] = templs;
  421.     }
  422.     else if (amount < 0)
  423.         for (i = y + numlines - 1,maxy = y - amount; i >= maxy; i--) {
  424.         templ = disp.plines[i];
  425.         templs = disp.pstyles[i];
  426.         disp.plines[i] = disp.plines[i + amount];
  427.         disp.pstyles[i] = disp.pstyles[i + amount];
  428.             disp.plines[i + amount] = templ;
  429.         disp.pstyles[i + amount] = templs;
  430.     }
  431.     }
  432.  
  433.     if (amount > 0) {
  434.     MAXBOUNDCK(amount, numlines);
  435.     DSEMPTYLINE(y + numlines - amount, y + numlines);
  436.     } else {
  437.     if ((amount = -amount) > numlines)
  438.         amount = numlines;
  439.     DSEMPTYLINE(y, y+amount);
  440.     }
  441. }
  442.  
  443. /*
  444.  * put a string at x, y
  445.  */
  446. static void wmputs(int x, int y, unsigned char *stng, int style)
  447. {
  448.     int len, pos; 
  449.     char temp[MAXWIDTH];
  450.     int wflag = (STYLEFLAG(y) & DOUBLE_MASK) != 0;
  451.  
  452.     if (disp.insert) {
  453.     register int linelen = LINELEN(y);
  454.     for (pos = 0; pos < MAXWIDTH-1 && (temp[pos] = stng[pos]); pos++);
  455.     for (len = x; pos < MAXWIDTH-1 && len < linelen; len++)
  456.         temp[pos++] = TEXTPOS(len, y);
  457.     temp[MAXBOUND(pos, (disp.winwidth >> wflag) - 1)] = '\0';
  458.     stng = temp;
  459.     } 
  460.     {
  461.         register int tx = SLIMIT((x),disp.winwidth);
  462.         register int ty = SLIMIT((y),disp.winheight);
  463.         register char *temp = (stng);
  464.         if (temp != NULL && *temp) {
  465.         for ((len) = LINELEN(ty); (len) < tx; (len)++) {
  466.             TEXTPOS((len), ty) = ' ';
  467.             STYLEPOS((len), ty) = 0;
  468.         }
  469.         /* stuff the characters into the buffer */
  470.         for ((len)=0;*temp;) {
  471.             (len)++;
  472.             TEXTPOS(tx,ty) = *temp++;
  473.             STYLEPOS(tx++,ty) = (style);
  474.         if (tx >= disp.winwidth) {
  475.             LINELENST(ty) = disp.winwidth;
  476.             tx=disp.winwidth-1;
  477.             break;
  478.             }
  479.         }
  480.         if (LINELEN(ty) < tx)
  481.             LINELENST(ty) = tx;
  482.         STYLEFLAG(y) |= (style);
  483.         }
  484.     }
  485.  
  486.     if (!rp)
  487.     return;
  488.  
  489. #if 0    
  490.     BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(x << wflag), POSY(y), 
  491.                       wm.font.w * len << wflag, wm.font.h, 
  492.               disp.invert ? BLACK : WHITE);
  493. #endif
  494.  
  495.     styleput(x, y, stng, len, style);
  496. }
  497.  
  498.     
  499. /*
  500.  * quick clear of the entire display
  501.  */
  502. void dsclearscreen(void)
  503. {
  504.     clear_display();
  505.     cursormode = 0;
  506.     if (rp) INVERTALL(disp.invert ? BLACK : WHITE);
  507.     clearSelection();
  508.     dssetfont(disp.style, disp.cury);
  509. }
  510.  
  511. /*
  512.  * clear region routines
  513.  */
  514. void dsclear(int x, int y, int x1, int y1)
  515. {
  516.     if (x > x1)
  517.     SWAP(x,x1);
  518.     if (y > y1)
  519.     SWAP(y,y1);
  520.  
  521.     DSCLEAR(x, y, x1, y1);
  522.  
  523.     if (rp) {
  524.     int wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) !=0;
  525.     BltBitMapRastPort(rp->BitMap, 0, 0, rp, 
  526.               POSX(x << wflag), 
  527.               POSY(y),
  528.               (x1 - x + 1) * wm.font.w << wflag, 
  529.               (y1 - y + 1) * wm.font.h,
  530.               (disp.invert ? BLACK : WHITE));
  531.     }
  532. }
  533.  
  534. /*
  535.  * delete n characters on current line into cursor
  536.  */
  537. void dsdelete(int n)
  538. {
  539.     char    deleteme[MAXWIDTH];
  540.     int        pos, i, linelen = LINELEN(disp.cury);
  541.     int wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) != 0;
  542.  
  543.     if (disp.curx + n >= (disp.winwidth >> wflag))
  544.     n = (disp.winwidth >> wflag) - disp.curx - 1;
  545.     if (!n)
  546.     return;
  547.     if ((pos = disp.curx + n) > linelen) {
  548.     if (linelen > disp.curx)
  549.         dsclear(disp.curx, disp.cury, linelen, disp.cury);
  550.     } else if (linelen) {
  551.     for (i = 0; pos < linelen; pos++)
  552.         deleteme[i++] = TEXTPOS(pos, disp.cury);
  553.     deleteme[i] = '\0';
  554.     dsclear(linelen - 1 - n, disp.cury, linelen - 1, disp.cury);
  555.     LINELENST(disp.cury) = linelen-n;
  556.     wmputs(disp.curx, disp.cury, deleteme, disp.style);
  557.     }
  558. }
  559.  
  560. /*
  561.  * put a string to the display
  562.  */
  563. void dsputs(char *s)
  564. {
  565.     int len = strlen(s), dlen;
  566.     char *temp, tempc;
  567.     int wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) != 0;
  568.     
  569.     for (temp = s; len; len -= dlen) {
  570.     if (vt100_yucky_wrap_mode) {
  571.         disp.curx = 0;
  572.         NEWLINE();
  573.         dssetfont(disp.style, disp.cury);
  574.         vt100_yucky_wrap_mode = 0;
  575.         wflag = (STYLEFLAG(disp.cury) & DOUBLE_MASK) != 0;
  576.     }
  577.     if (len > (disp.winwidth >> wflag) - disp.curx) {
  578.         dlen = (disp.winwidth >> wflag) - disp.curx;
  579.         tempc = temp[dlen];
  580.         temp[dlen]=0;
  581.         wmputs(disp.curx, disp.cury, temp, disp.style);
  582.         temp[dlen] = tempc;
  583.         if (!disp.wrap)
  584.         dlen = len-1;
  585.         temp += dlen;
  586.     } else {
  587.         dlen = len;
  588.         wmputs(disp.curx, disp.cury, temp, disp.style);
  589.         if (np.emulation == EMU_VT102 && 
  590.         disp.curx + dlen == (disp.winwidth >> wflag))
  591.         disp.curx--, vt100_yucky_wrap_mode = 1;
  592.     }
  593.     if ((disp.curx += dlen) >= (disp.winwidth >> wflag)) {
  594.         if (disp.wrap) {
  595.         NEWLINE();
  596.         disp.curx = 0;
  597.         } else
  598.         disp.curx = (disp.winwidth >> wflag) - 1;
  599.     }
  600.  
  601.     dssetfont(disp.style, disp.cury);
  602.     if (np.slow) {
  603.         udelay(100);
  604.     }
  605.     }
  606. }
  607.  
  608. /*
  609.  * invert screen or visual bell
  610.  */
  611. void dsinvert(int invtype)
  612. {
  613.     if (!rp)
  614.     return;
  615.  
  616.     switch (invtype) {
  617.     case INVERT_ON:
  618.         if (!disp.invert) {
  619.         disp.invert = 1;
  620.         INVERTALL(INVERT);
  621.         udelay(8000);
  622.         }
  623.         break;
  624.  
  625.     case INVERT_OFF:
  626.         if (disp.invert) {
  627.         disp.invert = 0;
  628.         INVERTALL(INVERT);
  629.         }
  630.         break;
  631.         
  632.     case VISUAL_BELL:
  633.             INVERTALL(INVERT);
  634.         udelay(10000);
  635.             INVERTALL(INVERT);
  636.         break;
  637.     }
  638. }
  639.  
  640. /*
  641.  * fill the screen with E's
  642.  */
  643. void dstestscreen(void)
  644. {
  645.     DSTEST('E', disp.style);
  646.     (void) redraw_display(1);
  647.     dscursoroff();
  648. }
  649.  
  650. /*
  651.  * Routines handling the selection
  652.  */
  653. #define    ISSELECTION \
  654. (selection.sx != selection.ex || selection.sy != selection.ey)
  655. #define    OUTSIDESEL(x,y)    \
  656.     ((y)<selection.sy || ((y)==selection.sy && (x) < selection.sx) ? \
  657.      -1 : \
  658.      ((y)>selection.ey || ((y)==selection.ey && (x) >= selection.ex) ? 1 : 0))
  659. #define    INSEL(x,y)    (!OUTSIDESEL(x,y))
  660. #define    SELTOPY        (selection.sy + (selection.sx ? 1 : 0))
  661. #define    SELBOTY        (selection.ey - 1)
  662. #define    POSITIVE(x)    ((x) < 0 ? 0 : (x))
  663. #define    ENDDIST(x,y) \
  664.     (POSITIVE(selection.ey-(y)) * disp.winwidth \
  665.      + disp.winwidth - 1 - (x) + selection.ex)
  666. #define    STDIST(x,y) \
  667.     (POSITIVE((y)-SELTOPY-1) * disp.winwidth  \
  668.      + disp.winwidth - 1 - selection.sx + (x))
  669. #define    NEAREND(x,y)    (ENDDIST(x,y) > STDIST(x,y))
  670. #define    REVSEL \
  671. (selection.sy > selection.ey || \
  672.  (selection.sy == selection.ey && selection.sx > selection.ex))
  673.  
  674. struct {
  675.     int    sx, sy,    ex, ey;        /* selection range */
  676. } selection;
  677.  
  678. /* Returns true if selected
  679.  */
  680. int isSelection(void) {
  681.     return ISSELECTION;
  682. }
  683.  
  684. /* Mouse selection handler
  685.  */
  686. void doselection(int action, int x, int y)
  687. {
  688.     int selection_on = ISSELECTION;
  689.  
  690.     if (!rp)
  691.       return;
  692.  
  693.     if (action == LBDOWN) {
  694.     if (ISSELECTION)
  695.         killSelection();
  696.     selection.sx = selection.ex = x;
  697.     selection.sy = selection.ey = y;
  698.  
  699.     } 
  700.     else if((action == LBUP) || (action == LMOVE)) {
  701.     if (selection.ex != x || selection.ey != y)
  702.         extendSelection(selection.ex,selection.ey,x,y);
  703.     selection.ex=x;
  704.     selection.ey=y;
  705.     if(action == LBUP) {
  706.         register int tmp;
  707.         tmp=selection.sy, selection.sy=selection.ey, selection.ey=tmp;
  708.         tmp=selection.sx, selection.sx=selection.ex, selection.ex=tmp;
  709.     }
  710.     }
  711.     if (ISSELECTION ^ selection_on)
  712.     dscursorblink();    
  713. }
  714.  
  715. /*
  716.  * grab a selection -- caller must free the buffer when finished.
  717.  */
  718. char *grabSelection(void)
  719. {
  720.     char *buffer, *temp;
  721.     int sx = selection.sx, ex = selection.ex, endx, endl;
  722.     int sy = selection.sy, ey = selection.ey;
  723.     int buflen;
  724.  
  725.     if (!ISSELECTION)
  726.     return (NULL);
  727.  
  728.     if (sy > ey || (sy == ey && sx > ex)) {
  729.     register int tmp;
  730.  
  731.     tmp = sy, sy=ey, ey = tmp;
  732.     tmp = sx, sx=ex, ex = tmp;
  733.     }
  734.  
  735.     buflen = (ey - sy + 2) * (disp.winwidth + 1); 
  736.     temp = buffer = AllocVec(buflen, MEMF_CLEAR);
  737.  
  738.     for (;sy <= ey; sy++) {
  739.     endx = LINELEN(sy);
  740.     if (sy == ey) {
  741.         MAXBOUNDCK(endx, ex);
  742.         endl = ex;
  743.     } else
  744.         endl = disp.winwidth;
  745.     for (;sx < endx; sx++)
  746.         *temp++ = TEXTPOS(sx, sy);
  747.     sx = 0;
  748.     if (endl > LINELEN(sy))
  749.         *temp++ = '\n';
  750.     }
  751.     *temp = 0;
  752.  
  753.     assert(temp < buffer + buflen);
  754.  
  755.     return (buffer);
  756. }
  757.  
  758. /* invert/extend the selection range
  759.  */
  760. void extendSelection(int sx, int sy, int ex, int ey)
  761. {
  762.   int topy, boty;
  763.  
  764.   if (sy > ey || (sy == ey && sx > ex)) {
  765.     register int tmp;
  766.  
  767.     tmp = sy, sy=ey, ey = tmp;
  768.     tmp = sx, sx=ex, ex = tmp;
  769.   }
  770.   topy = sy + (sx ? 1 : 0);
  771.   boty = ey - 1;
  772.   if (sx == ex && sy == ey)
  773.     return;
  774.   if (sy == ey) 
  775.     BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(sx), POSY(sy), 
  776.               wm.font.w*(ex-sx), wm.font.h, INVERT);
  777.   else {
  778.     if (sx && sx < disp.winwidth)
  779.       BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(sx), POSY(sy),
  780.             wm.font.w*(disp.winwidth-sx), wm.font.h, INVERT);
  781.     if (boty-topy+1 > 0)
  782.       BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(0), POSY(topy),
  783.             wm.font.w * disp.winwidth, 
  784.             wm.font.h * (boty - topy + 1), INVERT);
  785.     if (ex)
  786.       BltBitMapRastPort(rp->BitMap, 0, 0, rp, POSX(0), POSY(ey), 
  787.             wm.font.w*ex, wm.font.h, INVERT);
  788.   }
  789. }
  790.  
  791. void invertSelection(void)
  792. {
  793.     extendSelection(selection.sx, selection.sy, selection.ex, selection.ey);
  794. }
  795.  
  796. void killSelection(void)
  797. {
  798.     invertSelection();
  799.     selection.ey=selection.sy;
  800.     selection.ex=selection.sx;
  801. }
  802.  
  803. void clearSelection(void)
  804. {
  805.     selection.ey = selection.sy = selection.ex = selection.sx = 0;
  806. }
  807.  
  808. /*
  809.  * Initialization and cleanup
  810.  */
  811. int initdrawing(struct RastPort *rastport)
  812. {
  813.   if (!rp) {
  814.     myrp = *(rastport);
  815.     rp = &myrp;
  816.  
  817.     SetAPen(rp, 1);
  818.     SetBPen(rp, 0);
  819.     SetWrMsk(rp, 1);
  820.     SetDrMd(rp, DEFDRMD);
  821.     return 1;
  822.   } else {
  823.     return 0;
  824.   }
  825. }
  826.  
  827. void deinitdrawing(void)
  828. {
  829.     rp = NULL;
  830. }
  831.  
  832. #ifdef OWNICONIFY
  833. /* Do Not do ANYTHING after calling unmapwindow!! This is only used for 
  834.  * iconification.  Saves the state information, then closes the window.
  835.  */
  836. void
  837. unmapwindow(void)
  838. {
  839.     struct IntuiMessage *msg;
  840.     
  841.     while (msg = (struct IntuiMessage *)
  842.        GetMsg(w->UserPort)) ReplyMsg((struct Message *)msg);
  843.     DisplayOff = 1;
  844.     ClearMenuStrip(w);
  845.     nw.TopEdge = w->TopEdge;
  846.     nw.LeftEdge = w->LeftEdge;
  847.     nw.Width = w->Width;
  848.     nw.Height = w->Height;
  849.     nw.MaxWidth = w->MaxWidth;
  850.     nw.MaxHeight = w->MaxHeight;
  851.     nw.MinWidth = w->MinWidth;
  852.     nw.MinHeight = w->MinHeight;
  853.     nw.Flags = w->Flags;
  854.     nw.Title = w->Title;
  855.     CloseWindow(w);
  856.     rp = w = NULL;            /* no dangling references */
  857. }
  858.  
  859. /* Undoes a call to unmapwindow() everything should return to the way it was
  860.  * before the call 
  861.  */
  862. void
  863. mapwindow(void) 
  864. {
  865.     if(!(w = OpenWindow(&nw))) 
  866.         fatalError("Can't reopen window!!!!!");
  867.     /* We have a new RastPort!! */
  868.     myrp = *(w->RPort);
  869.     rp = &myrp;
  870.     SetAPen(rp, 1);
  871.     SetBPen(rp, 0);
  872.     SetWrMsk(rp, 1);
  873.     SetDrMd(rp, DEFDRMD);
  874.  
  875.     /* => setmenus() */
  876.     SetMenuStrip(w, &editmenu);
  877.     /* Now, everything should be back the way it was before */
  878.     DisplayOff = 0;
  879.     redraw_display(1);
  880. }
  881. #endif
  882.  
  883. /* Local Variables: */
  884. /* c-style:C++ */
  885. /* End: */
  886.